home *** CD-ROM | disk | FTP | other *** search
/ 17 Bit Software 6: Level 6 / 17 Bit - Level 6 (1998)(Epic Marketing)[!].iso / quartz / q1082.dms / q1082.adf / src.lzh / Fig / main.c < prev    next >
C/C++ Source or Header  |  1991-07-18  |  18KB  |  636 lines
  1. /* 
  2.  *    FIG : Facility for Interactive Generation of figures
  3.  *
  4.  *    Copyright (c) 1985 by Supoj Sutanthavibul (supoj@sally.UTEXAS.EDU)
  5.  *    1st revision : Aug 1985.
  6.  *
  7.  *    %W%    %G%
  8. */
  9. #include "fig.h"
  10. #include "const.h"
  11. #include "version.h"
  12.  
  13. extern int        borderwid, windowspacing, toolstripeht;
  14. extern int        ICON_COLUMN;
  15. extern int        CANVAS_HEIGHT, CANVAS_WIDTH;
  16. extern int        CANVAS_LEFT, CANVAS_TOP;
  17. extern int        PANEL_LEFT, PANEL_TOP, PANEL_HEIGHT, PANEL_WID;
  18. extern int        MSG_LEFT, MSG_TOP, MSG_WIDTH;
  19. extern int        SIDERULER_LEFT, SIDERULER_TOP;
  20. extern int        SIDERULER_WIDTH, SIDERULER_HEIGHT;
  21. extern int        SIDERULER_START;
  22. extern int        TOPRULER_LEFT, TOPRULER_TOP;
  23. extern int        TOPRULER_WIDTH, TOPRULER_HEIGHT;
  24. extern            (*canvas_rightbut_proc)();
  25. extern            set_popupmenu();
  26.  
  27. #ifdef    X11
  28. #include "fig.icon.X"
  29. Pixmap    fig_icon;
  30. #else
  31. #ifdef AMIGA
  32. #else
  33. #include "fig.icon"
  34. #define         FIG_ICON_WIDTH        MY_ICON_WIDTH
  35. #define         FIG_ICON_HEIGHT        MY_ICON_HEIGHT
  36.  
  37. mpr_static(fig_icon_pr, FIG_ICON_WIDTH, FIG_ICON_HEIGHT, 1, icon_data);
  38. static struct icon    fig_icon  =  {
  39.                 FIG_ICON_WIDTH+4, FIG_ICON_HEIGHT+4, NULL,
  40.                 {2, 2, FIG_ICON_WIDTH, FIG_ICON_HEIGHT},
  41.                 &fig_icon_pr, {0, 0, 0, 0}, NULL, NULL,
  42.                 ICON_BKGRDSET };
  43. #endif AMIGA
  44. #endif    /* X11*/
  45.  
  46. #include "resources.h"
  47. #define            SCREEN_WIDTH        1152
  48. #define            SCREEN_HEIGHT        900
  49. /*#define            min(a,b)        (((a) < (b)) ? (a) : (b))*/
  50.  
  51. static char    tool_name[80] = " FIG : FACILITY FOR INTERACTIVE GENERATION OF FIGURES ";
  52. static RECT        icon_rect, tool_rect;
  53. static            sigwinched();
  54.  
  55. /************** FIG options ******************/
  56.  
  57. extern int        DEBUG;
  58. extern int        RHS_PANEL;
  59. extern int        INVERSE;
  60. extern int        TRACKING;
  61.  
  62. TOOL            tool;
  63. int            WINDOW_WIDTH, WINDOW_HEIGHT;
  64. char            file_header[32] = "#FIG ";
  65. static char        *file = NULL;
  66.  
  67. int amicolor0=-1,amicolor1=-1;
  68. int amimag=8;
  69. int amistyle=0;
  70. char amifont[100]="topaz.font";
  71. get_args(argc, argv)
  72. int    argc;
  73. char    **argv;
  74. {
  75.     char    *option;
  76.  
  77.         CANVAS_HEIGHT = DEF_CANVAS_HEIGHT;
  78.         CANVAS_WIDTH = DEF_CANVAS_WIDTH;
  79.         ICON_COLUMN = ICON_COLUMN_PORT;
  80.     while (--argc > 0)  {
  81.        static int kom=0;
  82.        kom++;
  83.        option = *++argv;
  84.        if (*option == '-') {
  85.          while(*++option != '\0') {
  86.              switch(*option) {
  87.              case 'r':    /* put panel on right side */
  88.                  RHS_PANEL = 1;
  89.                  break;
  90.                  
  91.              case 'd':    /* turn on debugging */
  92.                  DEBUG = 1;
  93.                  break;
  94.                  
  95.              case 'p':   /* 8 X 10 portrait mode */
  96.              case 'P':
  97.                  CANVAS_HEIGHT = DEF_CANVAS_HEIGHT;
  98.                  CANVAS_WIDTH = DEF_CANVAS_WIDTH;
  99.                  ICON_COLUMN = ICON_COLUMN_PORT;
  100.                  break;
  101.                  
  102.              case 'l':   /* 10 X 8 landscape mode */
  103.              case 'L':
  104.                  CANVAS_HEIGHT = DEF_CANVAS_WIDTH;
  105.                  CANVAS_WIDTH = DEF_CANVAS_HEIGHT;
  106.                  ICON_COLUMN = ICON_COLUMN_LAND;
  107.                  break;
  108.                  
  109.              case 'w':    /* set width to size you want */
  110.                  CANVAS_WIDTH = atof(*++argv) * PIX_PER_INCH;
  111.                  argc--;
  112.                  break;
  113.                  
  114.              case 'h':    /* set height to size you want */
  115.                  CANVAS_HEIGHT = atof(*++argv) * PIX_PER_INCH;
  116.                  if( CANVAS_HEIGHT < DEF_CANVAS_HEIGHT)
  117.                      ICON_COLUMN = ICON_COLUMN_LAND;
  118.                  argc--;
  119.                  break;
  120.                  
  121.              case 'i':    /* reverse video */
  122.                  INVERSE = 1;
  123.                  invert_color();
  124.                  break;
  125.  
  126.              case 't':    /* turn on tracking */
  127.                  TRACKING = 1;
  128.                  break;
  129.  
  130.              case 'n':    /* turn off tracking */
  131.                  TRACKING = 0;
  132.                  break;
  133.                      
  134.              case 'c':
  135.                   switch(option[1])
  136.                   {case '0': sscanf(option+2,"%x",&amicolor0);break;
  137.                    case '1': sscanf(option+2,"%x",&amicolor1);break;
  138.                    default: printf("Only two colors, sorry.\n");_abort(1);}
  139.                  option+=4;
  140.                  break;
  141.              case 'f':
  142.                  {
  143.                  char * ptr;
  144.                   strcpy(amifont,option+1);
  145.                  ptr=strrchr(amifont,'.');
  146.                  if (ptr)
  147.                   {ptr++;
  148.                    if (atoi(ptr))
  149.                     {amimag=atoi(ptr);
  150.                      ptr[-1]=0;}}
  151.                  option+=strlen(option)-1;
  152.                  }
  153.                  break;
  154.              default:
  155.                  printf ("%s: Flag <%c> unrecognized\n", argv[0], *option);
  156.                  _abort(1);
  157.                  
  158.              }
  159.          }
  160.      }
  161.      else
  162.      {
  163.          file = option;
  164.          /*
  165.          switchwb(kom);
  166.          */
  167.      }
  168.     }
  169. }
  170.  
  171. #ifndef    X11
  172. #ifdef AMIGA
  173. main(argc, argv)
  174. int    argc;
  175. char    **argv;
  176. {
  177. /*    extern int WBenchMsg;*/
  178. /*    if (WBenchMsg)*/
  179. /*    parsewbargs(&argc,&argv);*/
  180.     get_args(argc, argv);
  181.     strcat(tool_name, FIG_VERSION);
  182.     strcat(file_header, FIG_VERSION);
  183. /*    printf("Initializing FIG %s%s (AmigaIntuition V1.3) ...\n", FIG_VERSION, MINOR_VERSION);*/
  184.     tool = tool_create(tool_name);
  185.     if (tool == (TOOL)0) _abort(1);
  186.     /*
  187.     compute_window_sizes();
  188.     set_window_size();
  189.     */
  190.  
  191.     init_font();
  192.     if (init_panel(tool) == 0) _abort(1);
  193.     if (init_canvas(tool) == 0) _abort(1);
  194.     if (init_msg(tool) == 0) _abort(1);
  195.     if (init_sideruler(tool) == 0) _abort(1);
  196.     if (init_topruler(tool) == 0) _abort(1);
  197.     /*
  198.     set_subwindow_sizes();
  199.     */
  200.  
  201.     if (file != NULL) {
  202.         edit_file(file);
  203.         }
  204.     /*
  205.     signal(SIGWINCH, sigwinched);
  206.     */
  207.     canvas_rightbut_proc = set_popupmenu;
  208.     tool_install(tool);
  209.     for(;;) {
  210.         HandleInput();
  211.         quit();    /* This is where one of the exit points is */
  212.         }
  213. }
  214. #else
  215. main(argc, argv)
  216. int    argc;
  217. char    **argv;
  218. {
  219.     ICON_COLUMN = ICON_COLUMN_PORT;
  220.     get_args(argc, argv);
  221.     strcat(tool_name, FIG_VERSION);
  222.     strcat(file_header, FIG_VERSION);
  223.     printf("Initializing FIG %s%s (SunView) ...\n", FIG_VERSION, MINOR_VERSION);
  224.     tool = tool_create(tool_name, TOOL_NAMESTRIPE, NULL, &fig_icon);
  225.     if (tool == (TOOL)0) exit(1);
  226.     compute_window_sizes();
  227.     set_window_size();
  228.  
  229.     init_font();
  230.     if (init_panel(tool) == 0) exit(1);
  231.     if (init_canvas(tool) == 0) exit(1);
  232.     if (init_msg(tool) == 0) exit(1);
  233.     if (init_sideruler(tool) == 0) exit(1);
  234.     if (init_topruler(tool) == 0) exit(1);
  235.     set_subwindow_sizes();
  236.  
  237.     if (file != NULL) {
  238.         edit_file(file);
  239.         }
  240.     signal(SIGWINCH, sigwinched);
  241.     canvas_rightbut_proc = set_popupmenu;
  242.     tool_install(tool);
  243.     for(;;) {
  244.         tool_select(tool, 0);
  245.         quit();    /* This is where one of the exit points is */
  246.         }
  247. }
  248. #endif AMIGA
  249. #else
  250.  
  251. static int true = True;
  252. static int false = False;
  253. static int zero = 0;
  254. int    landscape;
  255. float    tmp_width = 0.0, tmp_height = 0.0;
  256.  
  257. static XtResource application_resources[] = {
  258.     {XtNjustify, XtCJustify, XtRBoolean, sizeof(int),
  259.          (Cardinal)&RHS_PANEL, XtRBoolean, (caddr_t)&false},
  260.     {"debug", "Debug", XtRBoolean, sizeof(int),
  261.          (Cardinal)&DEBUG, XtRBoolean, (caddr_t)&false},
  262.     {"landscape", XtCOrientation, XtRBoolean, sizeof(int),
  263.          (Cardinal)&landscape, XtRBoolean, (caddr_t)&false},
  264.     {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
  265.          (Cardinal)&tmp_width, XtRInt, (caddr_t)&zero},
  266.     {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
  267.          (Cardinal)&tmp_height, XtRInt, (caddr_t)&zero},
  268.     {XtNreverseVideo, XtCReverseVideo, XtRBoolean, sizeof(int),
  269.          (Cardinal)&INVERSE, XtRBoolean, (caddr_t)&false},
  270.     {"trackCursor", "Track", XtRBoolean, sizeof(int),
  271.          (Cardinal)&TRACKING, XtRBoolean, (caddr_t)&true},
  272. };
  273.  
  274. static XrmOptionDescRec options[] =
  275. {
  276.     {"-right", ".justify", XrmoptionNoArg, "True" },
  277.     {"-left", ".justify", XrmoptionNoArg, "False"},
  278.     {"-debug", ".debug", XrmoptionNoArg, "True"},
  279.     {"-landscape", ".landscape", XrmoptionNoArg, "True"},
  280.     {"-Landscape", ".landscape", XrmoptionNoArg, "True"},
  281.     {"-portrait", ".landscape", XrmoptionNoArg, "False"},
  282.     {"-Portrait", ".landscape", XrmoptionNoArg, "False"},
  283.     {"-width", ".width", XrmoptionSepArg, 0},
  284.     {"-height", ".height", XrmoptionSepArg, 0},
  285.     {"-inverse", ".reverseVideo", XrmoptionNoArg, "True"},
  286.     {"-notrack", ".trackCursor", XrmoptionNoArg, "False"},
  287.     {"-track", ".trackCursor", XrmoptionNoArg, "True"},
  288. };
  289.  
  290. static XtCallbackRec    callbacks[] =
  291. {
  292.     { NULL, NULL },
  293. };
  294.  
  295. static Arg    form_args[] =
  296. {
  297.     { XtNcallback, (XtArgVal)callbacks },
  298. };
  299.  
  300. main(argc,argv)
  301.     int        argc;
  302.     char        *argv[];
  303. {
  304.     TOOL        form, children[5];
  305.     Arg        tmp_arg[2];
  306.     int        init_panel(), init_msg(), init_canvas(),
  307.             init_sideruler(), init_topruler();
  308.  
  309.     strcat(tool_name, FIG_VERSION);
  310.     strcat(file_header, FIG_VERSION);
  311.     printf("Initializing FIG %s%s (X11) ... \n", FIG_VERSION, MINOR_VERSION);
  312.     tool = XtInitialize("fig", "Fig", options, XtNumber(options),
  313.         &argc, argv);
  314.  
  315.     fix_converters();
  316.     XtGetApplicationResources(tool, 0, application_resources,
  317.                                    XtNumber(application_resources), NULL, 0 );
  318.     if (argc > 1)
  319.         file = argv[1];
  320.  
  321.     tool_d = XtDisplay(tool);
  322.     tool_s = XtScreen(tool);
  323.     tool_sn = DefaultScreen(tool_d);
  324.     
  325.     gc = DefaultGC(tool_d, tool_sn);
  326.  
  327.     if( CellsOfScreen(tool_s) == 2 && INVERSE )
  328.     {
  329.         XrmValue    value;
  330.         XrmDatabase newdb = (XrmDatabase) 0;
  331.         XrmDatabase XtDefaultDB = newdb;
  332.  
  333.         value.size = sizeof("White");
  334.         value.addr = "White";
  335.         XrmPutResource(&newdb, "xfig*borderColor", "String",
  336.                    &value);
  337.         value.size = sizeof("White");
  338.         value.addr = "White";
  339.         XrmPutResource(&newdb, "xfig*foreground", "String",
  340.                    &value);
  341.         value.size = sizeof("Black");
  342.         value.addr = "Black";
  343.         XrmPutResource(&newdb, "xfig*background", "String",
  344.                    &value);
  345.         XrmMergeDatabases(newdb, &XtDefaultDB);
  346.  
  347.         /* now set the tool part, since its already created */
  348.         XtSetArg(tmp_arg[0], XtNborderColor,
  349.              WhitePixelOfScreen(tool_s));
  350.         XtSetArg(tmp_arg[1], XtNforeground,
  351.              WhitePixelOfScreen(tool_s));
  352.         XtSetArg(tmp_arg[2], XtNbackground,
  353.              BlackPixelOfScreen(tool_s));
  354.         XtSetValues(tool, tmp_arg, 3);
  355.     }
  356.     
  357.     init_font();
  358.     init_cursor();
  359.     form = XtCreateManagedWidget("form", formWidgetClass, tool,
  360.         form_args, XtNumber(form_args));
  361.     
  362.     ICON_COLUMN = ICON_COLUMN_PORT;
  363.     CANVAS_WIDTH = tmp_width * PIX_PER_INCH;
  364.     CANVAS_HEIGHT = tmp_height * PIX_PER_INCH;
  365.  
  366.     if( CANVAS_WIDTH == 0 )
  367.         CANVAS_WIDTH = landscape ? DEF_CANVAS_HEIGHT :
  368.                 DEF_CANVAS_WIDTH;
  369.     
  370.     if( CANVAS_HEIGHT == 0 )
  371.         CANVAS_HEIGHT = landscape ? DEF_CANVAS_WIDTH :
  372.             DEF_CANVAS_HEIGHT;
  373.     
  374.     if( (CANVAS_HEIGHT < DEF_CANVAS_HEIGHT) ||
  375.        (HeightOfScreen(tool_s) < DEF_CANVAS_HEIGHT) )
  376.         ICON_COLUMN = ICON_COLUMN_LAND;
  377.         
  378.     (void)init_panel(form);
  379.     children[0] = panel_sw;
  380.     (void)init_topruler(form);
  381.     children[1] = topruler_sw;
  382.     (void)init_menu(form);
  383.     (void)init_canvas(form);
  384.     children[2] = canvas_sw;
  385.     (void)init_msg(form);
  386.     children[3] = msg_sw;
  387.     (void)init_sideruler(form);
  388.     children[4] = sideruler_sw;
  389.     XtManageChildren(children, 5);
  390.     XtRealizeWidget(tool);
  391.     if( RHS_PANEL )
  392.     {
  393.         XtSetArg(tmp_arg[0], XtNfromHoriz, 0);
  394.         XtSetArg(tmp_arg[1], XtNhorizDistance, RULER_WIDTH+2);
  395.         XtSetValues(topruler_sw, tmp_arg, 2);
  396.         XtSetArg(tmp_arg[0], XtNfromHoriz, 0);
  397.         XtSetArg(tmp_arg[1], XtNfromVert, topruler_sw);
  398.         XtSetValues(sideruler_sw, tmp_arg, 2);
  399.         XtUnmanageChild(msg_sw);
  400.         XtSetArg(tmp_arg[0], XtNfromHoriz, sideruler_sw);
  401.         XtSetArg(tmp_arg[1], XtNfromVert, topruler_sw);
  402.         XtSetValues(canvas_sw, tmp_arg, 2);
  403.         XtManageChild(msg_sw);
  404.         XtSetArg(tmp_arg[0], XtNfromHoriz, canvas_sw);
  405.         XtSetArg(tmp_arg[1], XtNfromVert, 0);
  406.         XtSetValues(panel_sw, tmp_arg, 2);
  407.         XtSetArg(tmp_arg[0], XtNfromHoriz, sideruler_sw);
  408.         XtSetArg(tmp_arg[1], XtNfromVert, canvas_sw);
  409.         XtSetValues(msg_sw, tmp_arg, 2);
  410.         XtUnmanageChild(msg_sw);
  411.         XtManageChild(msg_sw);
  412.     }
  413.     init_gc();
  414.     setup_panel();
  415.     setup_rulers();
  416.     setup_canvas();
  417.     setup_msg();
  418.     canvas_rightbut_proc = set_popupmenu;
  419.     if (file != NULL)
  420.         edit_file(file);
  421.     (void)signal(SIGINT, SIG_IGN);    /* so we don't lose work accidentally */
  422.     fig_icon = XCreateBitmapFromData(tool_d, XtWindow(tool),
  423.                      fig_bits, fig_width, fig_height);
  424.     
  425.     XtSetArg(tmp_arg[0], XtNtitle, tool_name);
  426.     XtSetArg(tmp_arg[1], XtNiconPixmap, fig_icon);
  427.     XtSetValues(tool, tmp_arg, 2);
  428.     
  429.     XtMainLoop();
  430. }
  431. #endif    X11
  432.  
  433. #ifndef    X11
  434. #ifdef AMIGA
  435. #else
  436. #define        TOPRULER_CANVAS_SPACING        5
  437. #define        SIDERULER_CANVAS_SPACING    5
  438. #define        PANEL_CANVAS_SPACING        5
  439. #define        PANEL_MSG_SPACING        5
  440.  
  441. compute_window_sizes()
  442. {
  443.     borderwid = tool_borderwidth(tool);
  444.     windowspacing = tool_subwindowspacing(tool);
  445.     toolstripeht = tool_stripeheight(tool);
  446.     PANEL_WID = ICON_COLUMN * SWITCH_ICON_WIDTH;
  447.     PANEL_HEIGHT = RULER_WIDTH + CANVAS_HEIGHT + TOPRULER_CANVAS_SPACING;
  448.     PANEL_TOP = toolstripeht + 2;
  449.     MSG_WIDTH = PANEL_WID + RULER_WIDTH + CANVAS_WIDTH
  450.         + SIDERULER_CANVAS_SPACING + PANEL_CANVAS_SPACING;
  451.     MSG_TOP = PANEL_HEIGHT + PANEL_TOP + PANEL_MSG_SPACING;
  452.     MSG_LEFT = borderwid;
  453.  
  454.     TOPRULER_TOP = PANEL_TOP;
  455.     TOPRULER_WIDTH = CANVAS_WIDTH;
  456.     TOPRULER_HEIGHT = RULER_WIDTH;
  457.  
  458.     CANVAS_TOP = TOPRULER_TOP + RULER_WIDTH + TOPRULER_CANVAS_SPACING;
  459.  
  460.     SIDERULER_TOP = TOPRULER_TOP;
  461.     SIDERULER_WIDTH = RULER_WIDTH;
  462.     SIDERULER_HEIGHT = PANEL_HEIGHT;
  463.     SIDERULER_START = RULER_WIDTH + TOPRULER_CANVAS_SPACING;
  464.  
  465.     WINDOW_WIDTH = borderwid + borderwid + MSG_WIDTH;
  466.     WINDOW_HEIGHT = MSG_TOP + MSG_HEIGHT + borderwid;
  467.  
  468.     if (RHS_PANEL) { /* panel on the right of drawing area */
  469.         SIDERULER_LEFT = borderwid;
  470.         CANVAS_LEFT = SIDERULER_LEFT + RULER_WIDTH
  471.             + SIDERULER_CANVAS_SPACING;
  472.         PANEL_LEFT = CANVAS_LEFT + CANVAS_WIDTH + PANEL_CANVAS_SPACING;
  473.         TOPRULER_LEFT = CANVAS_LEFT;
  474.         }
  475.     else {
  476.         PANEL_LEFT = borderwid;
  477.         CANVAS_LEFT = PANEL_LEFT + PANEL_WID + PANEL_CANVAS_SPACING;
  478.         SIDERULER_LEFT = CANVAS_LEFT + CANVAS_WIDTH
  479.             + SIDERULER_CANVAS_SPACING;
  480.         TOPRULER_LEFT = CANVAS_LEFT;
  481.         }
  482.     }
  483.  
  484. set_window_size()
  485. {
  486.     if (wmgr_iswindowopen(tool->tl_windowfd) )  {
  487.         win_getrect(tool->tl_windowfd, &tool_rect);
  488.         win_getsavedrect(tool->tl_windowfd, &icon_rect);
  489.         }
  490.     else {
  491.         win_getrect(tool->tl_windowfd, &icon_rect);
  492.         win_getsavedrect(tool->tl_windowfd, &tool_rect);
  493.         }
  494.     if (tool_rect.r_width != WINDOW_WIDTH
  495.         || tool_rect.r_height != WINDOW_HEIGHT) {
  496.         tool_rect.r_width = WINDOW_WIDTH;
  497.         tool_rect.r_height = WINDOW_HEIGHT;
  498.         icon_rect.r_left = min(icon_rect.r_left, SCREEN_WIDTH-FIG_ICON_WIDTH-4);
  499.         icon_rect.r_top = min(icon_rect.r_top, SCREEN_HEIGHT-FIG_ICON_HEIGHT-4);
  500.         if (tool_rect.r_left < 0
  501.             || tool_rect.r_left + tool_rect.r_width > SCREEN_WIDTH
  502.             || tool_rect.r_top < 0
  503.             || tool_rect.r_top + tool_rect.r_height > SCREEN_HEIGHT) {
  504.         tool_rect.r_left  = 300;
  505.         tool_rect.r_top   = 10;
  506.         }
  507.         if (wmgr_iswindowopen(tool->tl_windowfd) )  {
  508.         win_setrect(tool->tl_windowfd, &tool_rect);
  509.         win_setsavedrect(tool->tl_windowfd, &icon_rect);
  510.         }
  511.         else {
  512.         win_setrect(tool->tl_windowfd, &icon_rect);
  513.         win_setsavedrect(tool->tl_windowfd, &tool_rect);
  514.         }
  515.         }
  516.     }
  517.  
  518. static
  519. sigwinched()
  520. {
  521.     tool_sigwinch(tool);
  522.     set_window_size();
  523.     set_subwindow_sizes();
  524.     }
  525.  
  526. set_subwindow_sizes()
  527. {
  528.     set_window(panel_sw, PANEL_TOP, PANEL_LEFT, PANEL_WID, PANEL_HEIGHT);
  529.     set_window(msg_sw, MSG_TOP, MSG_LEFT, MSG_WIDTH, MSG_HEIGHT);
  530.     set_window(canvas_sw, CANVAS_TOP, CANVAS_LEFT, CANVAS_WIDTH,
  531.             CANVAS_HEIGHT);
  532.     set_window(sideruler_sw, SIDERULER_TOP, SIDERULER_LEFT, RULER_WIDTH,
  533.             SIDERULER_HEIGHT);
  534.     set_window(topruler_sw, TOPRULER_TOP, TOPRULER_LEFT, CANVAS_WIDTH,
  535.             RULER_WIDTH);
  536.     }
  537.  
  538. set_window(win, t, l, w, h)
  539. TOOLSW        win;
  540. int        t, l, w, h;
  541. {
  542.     RECT        r;
  543.  
  544.     if (wmgr_iswindowopen(tool->tl_windowfd) )
  545.         win_getrect(win->ts_windowfd, &r);
  546.     else 
  547.         win_getsavedrect(win->ts_windowfd, &r);
  548.  
  549.     if (r.r_top!= t || r.r_left != l || r.r_width != w || r.r_height != h) {
  550.         r.r_top = t;
  551.         r.r_left = l;
  552.         r.r_width = w;
  553.         r.r_height = h;
  554.         if (wmgr_iswindowopen(tool->tl_windowfd))
  555.         win_setrect(win->ts_windowfd, &r);
  556.         else 
  557.         win_setsavedrect(win->ts_windowfd, &r);
  558.         }
  559.     }
  560. #endif AMIGA
  561. #endif    X11
  562.  
  563. /*
  564.     if (wmgr_iswindowopen(tool->tl_windowfd) )
  565.         win_getrect(msg_sw->ts_windowfd, &msg_rect);
  566.     else 
  567.         win_getsavedrect(msg_sw->ts_windowfd, &msg_rect);
  568.     if ( msg_rect.r_top != MSG_TOP || msg_rect.r_left != MSG_LEFT ||  
  569.         msg_rect.r_width != MSG_WIDTH ||  
  570.         msg_rect.r_height != MSG_HEIGHT) {
  571.         msg_rect.r_top = MSG_TOP;
  572.         msg_rect.r_left = MSG_LEFT;
  573.         msg_rect.r_width = MSG_WIDTH;
  574.         msg_rect.r_height = MSG_HEIGHT;
  575.         if (wmgr_iswindowopen(tool->tl_windowfd))
  576.         win_setrect(msg_sw->ts_windowfd, &msg_rect);
  577.         else 
  578.         win_setsavedrect(msg_sw->ts_windowfd, &msg_rect);
  579.         }
  580.  
  581.     if (wmgr_iswindowopen(tool->tl_windowfd) )
  582.         win_getrect(canvas_sw->ts_windowfd, &canvas_rect);
  583.     else 
  584.         win_getsavedrect(canvas_sw->ts_windowfd, &canvas_rect);
  585.     if (canvas_rect.r_top != CANVAS_TOP || 
  586.         canvas_rect.r_left != CANVAS_LEFT ||
  587.         canvas_rect.r_width != CANVAS_WIDTH || 
  588.         canvas_rect.r_height != CANVAS_HEIGHT) {
  589.         canvas_rect.r_top = CANVAS_TOP;
  590.         canvas_rect.r_left = CANVAS_LEFT;
  591.         canvas_rect.r_width = CANVAS_WIDTH;
  592.         canvas_rect.r_height = CANVAS_HEIGHT;
  593.         if (wmgr_iswindowopen(tool->tl_windowfd))
  594.         win_setrect(canvas_sw->ts_windowfd, &canvas_rect);
  595.         else 
  596.         win_setsavedrect(canvas_sw->ts_windowfd, &canvas_rect);
  597.         }
  598.  
  599.     if (wmgr_iswindowopen(tool->tl_windowfd) )
  600.         win_getrect(topruler_sw->ts_windowfd, &topruler_rect);
  601.     else 
  602.         win_getsavedrect(topruler_sw->ts_windowfd, &topruler_rect);
  603.     if (topruler_rect.r_top != TOPRULER_TOP || 
  604.         topruler_rect.r_left != TOPRULER_LEFT ||
  605.         topruler_rect.r_width != CANVAS_WIDTH || 
  606.         topruler_rect.r_height != RULER_WIDTH) {
  607.         topruler_rect.r_top = TOPRULER_TOP;
  608.         topruler_rect.r_left = TOPRULER_LEFT;
  609.         topruler_rect.r_width = TOPRULER_WIDTH;
  610.         topruler_rect.r_height = TOPRULER_HEIGHT;
  611.         if (wmgr_iswindowopen(tool->tl_windowfd))
  612.         win_setrect(topruler_sw->ts_windowfd, &topruler_rect);
  613.         else 
  614.         win_setsavedrect(topruler_sw->ts_windowfd, &topruler_rect);
  615.         }
  616.  
  617.     if (wmgr_iswindowopen(tool->tl_windowfd) )
  618.         win_getrect(sideruler_sw->ts_windowfd, &sideruler_rect);
  619.     else 
  620.         win_getsavedrect(sideruler_sw->ts_windowfd, &sideruler_rect);
  621.     if (sideruler_rect.r_top != SIDERULER_TOP || 
  622.         sideruler_rect.r_left != SIDERULER_LEFT ||
  623.         sideruler_rect.r_width != RULER_WIDTH || 
  624.         sideruler_rect.r_height != SIDERULER_HEIGHT) {
  625.         sideruler_rect.r_top = SIDERULER_TOP;
  626.         sideruler_rect.r_left = SIDERULER_LEFT;
  627.         sideruler_rect.r_width = SIDERULER_WIDTH;
  628.         sideruler_rect.r_height = SIDERULER_HEIGHT;
  629.         if (wmgr_iswindowopen(tool->tl_windowfd))
  630.         win_setrect(sideruler_sw->ts_windowfd, &sideruler_rect);
  631.         else 
  632.         win_setsavedrect(sideruler_sw->ts_windowfd, &sideruler_rect);
  633.         }
  634.     }
  635. */
  636.